this.BX = this.BX || {};
(function (exports) {
  'use strict';

  // canvas-confetti v1.2.0 built on 2020-09-03T11:51:26.027Z
  var module$1 = {}; // source content

  (function main(global, module, isWorker, workerSize) {
    var canUseWorker = !!(global.Worker && global.Blob && global.Promise && global.OffscreenCanvas && global.HTMLCanvasElement && global.HTMLCanvasElement.prototype.transferControlToOffscreen && global.URL && global.URL.createObjectURL);

    function noop() {} // create a promise if it exists, otherwise, just
    // call the function directly


    function promise(func) {
      var ModulePromise = module.exports.Promise;
      var Prom = ModulePromise !== void 0 ? ModulePromise : global.Promise;

      if (typeof Prom === 'function') {
        return new Prom(func);
      }

      func(noop, noop);
      return null;
    }

    var raf = function () {
      var TIME = Math.floor(1000 / 60);
      var frame, cancel;
      var frames = {};
      var lastFrameTime = 0;

      if (typeof requestAnimationFrame === 'function' && typeof cancelAnimationFrame === 'function') {
        frame = function frame(cb) {
          var id = Math.random();
          frames[id] = requestAnimationFrame(function onFrame(time) {
            if (lastFrameTime === time || lastFrameTime + TIME - 1 < time) {
              lastFrameTime = time;
              delete frames[id];
              cb();
            } else {
              frames[id] = requestAnimationFrame(onFrame);
            }
          });
          return id;
        };

        cancel = function cancel(id) {
          if (frames[id]) {
            cancelAnimationFrame(frames[id]);
          }
        };
      } else {
        frame = function frame(cb) {
          return setTimeout(cb, TIME);
        };

        cancel = function cancel(timer) {
          return clearTimeout(timer);
        };
      }

      return {
        frame: frame,
        cancel: cancel
      };
    }();

    var getWorker = function () {
      var worker;
      var prom;
      var resolves = {};

      function decorate(worker) {
        function execute(options, callback) {
          worker.postMessage({
            options: options || {},
            callback: callback
          });
        }

        worker.init = function initWorker(canvas) {
          var offscreen = canvas.transferControlToOffscreen();
          worker.postMessage({
            canvas: offscreen
          }, [offscreen]);
        };

        worker.fire = function fireWorker(options, size, done) {
          if (prom) {
            execute(options, null);
            return prom;
          }

          var id = Math.random().toString(36).slice(2);
          prom = promise(function (resolve) {
            function workerDone(msg) {
              if (msg.data.callback !== id) {
                return;
              }

              delete resolves[id];
              worker.removeEventListener('message', workerDone);
              prom = null;
              done();
              resolve();
            }

            worker.addEventListener('message', workerDone);
            execute(options, id);
            resolves[id] = workerDone.bind(null, {
              data: {
                callback: id
              }
            });
          });
          return prom;
        };

        worker.reset = function resetWorker() {
          worker.postMessage({
            reset: true
          });

          for (var id in resolves) {
            resolves[id]();
            delete resolves[id];
          }
        };
      }

      return function () {
        if (worker) {
          return worker;
        }

        if (!isWorker && canUseWorker) {
          var code = ['var CONFETTI, SIZE = {}, module = {};', '(' + main.toString() + ')(this, module, true, SIZE);', 'onmessage = function(msg) {', '  if (msg.data.options) {', '    CONFETTI(msg.data.options).then(function () {', '      if (msg.data.callback) {', '        postMessage({ callback: msg.data.callback });', '      }', '    });', '  } else if (msg.data.reset) {', '    CONFETTI.reset();', '  } else if (msg.data.resize) {', '    SIZE.width = msg.data.resize.width;', '    SIZE.height = msg.data.resize.height;', '  } else if (msg.data.canvas) {', '    SIZE.width = msg.data.canvas.width;', '    SIZE.height = msg.data.canvas.height;', '    CONFETTI = module.exports.create(msg.data.canvas);', '  }', '}'].join('\n');

          try {
            worker = new Worker(URL.createObjectURL(new Blob([code])));
          } catch (e) {
            // eslint-disable-next-line no-console
            (typeof console === "undefined" ? "undefined" : babelHelpers["typeof"](console)) !== undefined && typeof console.warn === 'function' ? console.warn('рџЋЉ Count not load worker', e) : null;
            return null;
          }

          decorate(worker);
        }

        return worker;
      };
    }();

    var defaults = {
      particleCount: 50,
      angle: 90,
      spread: 45,
      startVelocity: 45,
      decay: 0.9,
      gravity: 1,
      ticks: 200,
      x: 0.5,
      y: 0.5,
      shapes: ['square', 'circle'],
      zIndex: 100,
      colors: ['#26ccff', '#a25afd', '#ff5e7e', '#88ff5a', '#fcff42', '#ffa62d', '#ff36ff'],
      // probably should be true, but back-compat
      disableForReducedMotion: false
    };

    function convert(val, transform) {
      return transform ? transform(val) : val;
    }

    function isOk(val) {
      return !(val === null || val === undefined);
    }

    function prop(options, name, transform) {
      return convert(options && isOk(options[name]) ? options[name] : defaults[name], transform);
    }

    function randomInt(min, max) {
      // [min, max)
      return Math.floor(Math.random() * (max - min)) + min;
    }

    function toDecimal(str) {
      return parseInt(str, 16);
    }

    function hexToRgb(str) {
      var val = String(str).replace(/[^0-9a-f]/gi, '');

      if (val.length < 6) {
        val = val[0] + val[0] + val[1] + val[1] + val[2] + val[2];
      }

      return {
        r: toDecimal(val.substring(0, 2)),
        g: toDecimal(val.substring(2, 4)),
        b: toDecimal(val.substring(4, 6))
      };
    }

    function getOrigin(options) {
      var origin = prop(options, 'origin', Object);
      origin.x = prop(origin, 'x', Number);
      origin.y = prop(origin, 'y', Number);
      return origin;
    }

    function setCanvasWindowSize(canvas) {
      canvas.width = document.documentElement.clientWidth;
      canvas.height = document.documentElement.clientHeight;
    }

    function setCanvasRectSize(canvas) {
      var rect = canvas.getBoundingClientRect();
      canvas.width = rect.width;
      canvas.height = rect.height;
    }

    function getCanvas(zIndex) {
      var canvas = document.createElement('canvas');
      canvas.style.position = 'fixed';
      canvas.style.top = '0px';
      canvas.style.left = '0px';
      canvas.style.pointerEvents = 'none';
      canvas.style.zIndex = zIndex;
      return canvas;
    }

    function ellipse(context, x, y, radiusX, radiusY, rotation, startAngle, endAngle, antiClockwise) {
      context.save();
      context.translate(x, y);
      context.rotate(rotation);
      context.scale(radiusX, radiusY);
      context.arc(0, 0, 1, startAngle, endAngle, antiClockwise);
      context.restore();
    }

    function randomPhysics(opts) {
      var radAngle = opts.angle * (Math.PI / 180);
      var radSpread = opts.spread * (Math.PI / 180);
      return {
        x: opts.x,
        y: opts.y,
        wobble: Math.random() * 10,
        velocity: opts.startVelocity * 0.5 + Math.random() * opts.startVelocity,
        angle2D: -radAngle + (0.5 * radSpread - Math.random() * radSpread),
        tiltAngle: Math.random() * Math.PI,
        color: hexToRgb(opts.color),
        shape: opts.shape,
        tick: 0,
        totalTicks: opts.ticks,
        decay: opts.decay,
        random: Math.random() + 5,
        tiltSin: 0,
        tiltCos: 0,
        wobbleX: 0,
        wobbleY: 0,
        gravity: opts.gravity * 3,
        ovalScalar: 0.6
      };
    }

    function updateFetti(context, fetti) {
      fetti.x += Math.cos(fetti.angle2D) * fetti.velocity;
      fetti.y += Math.sin(fetti.angle2D) * fetti.velocity + fetti.gravity;
      fetti.wobble += 0.1;
      fetti.velocity *= fetti.decay;
      fetti.tiltAngle += 0.1;
      fetti.tiltSin = Math.sin(fetti.tiltAngle);
      fetti.tiltCos = Math.cos(fetti.tiltAngle);
      fetti.random = Math.random() + 5;
      fetti.wobbleX = fetti.x + 10 * Math.cos(fetti.wobble);
      fetti.wobbleY = fetti.y + 10 * Math.sin(fetti.wobble);
      var progress = fetti.tick++ / fetti.totalTicks;
      var x1 = fetti.x + fetti.random * fetti.tiltCos;
      var y1 = fetti.y + fetti.random * fetti.tiltSin;
      var x2 = fetti.wobbleX + fetti.random * fetti.tiltCos;
      var y2 = fetti.wobbleY + fetti.random * fetti.tiltSin;
      context.fillStyle = 'rgba(' + fetti.color.r + ', ' + fetti.color.g + ', ' + fetti.color.b + ', ' + (1 - progress) + ')';
      context.beginPath();

      if (fetti.shape === 'circle') {
        context.ellipse ? context.ellipse(fetti.x, fetti.y, Math.abs(x2 - x1) * fetti.ovalScalar, Math.abs(y2 - y1) * fetti.ovalScalar, Math.PI / 10 * fetti.wobble, 0, 2 * Math.PI) : ellipse(context, fetti.x, fetti.y, Math.abs(x2 - x1) * fetti.ovalScalar, Math.abs(y2 - y1) * fetti.ovalScalar, Math.PI / 10 * fetti.wobble, 0, 2 * Math.PI);
      } else {
        context.moveTo(Math.floor(fetti.x), Math.floor(fetti.y));
        context.lineTo(Math.floor(fetti.wobbleX), Math.floor(y1));
        context.lineTo(Math.floor(x2), Math.floor(y2));
        context.lineTo(Math.floor(x1), Math.floor(fetti.wobbleY));
      }

      context.closePath();
      context.fill();
      return fetti.tick < fetti.totalTicks;
    }

    function animate(canvas, fettis, resizer, size, done) {
      var animatingFettis = fettis.slice();
      var context = canvas.getContext('2d');
      var animationFrame;
      var destroy;
      var prom = promise(function (resolve) {
        function onDone() {
          animationFrame = destroy = null;
          context.clearRect(0, 0, size.width, size.height);
          done();
          resolve();
        }

        function update() {
          if (isWorker && !(size.width === workerSize.width && size.height === workerSize.height)) {
            size.width = canvas.width = workerSize.width;
            size.height = canvas.height = workerSize.height;
          }

          if (!size.width && !size.height) {
            resizer(canvas);
            size.width = canvas.width;
            size.height = canvas.height;
          }

          context.clearRect(0, 0, size.width, size.height);
          animatingFettis = animatingFettis.filter(function (fetti) {
            return updateFetti(context, fetti);
          });

          if (animatingFettis.length) {
            animationFrame = raf.frame(update);
          } else {
            onDone();
          }
        }

        animationFrame = raf.frame(update);
        destroy = onDone;
      });
      return {
        addFettis: function addFettis(fettis) {
          animatingFettis = animatingFettis.concat(fettis);
          return prom;
        },
        canvas: canvas,
        promise: prom,
        reset: function reset() {
          if (animationFrame) {
            raf.cancel(animationFrame);
          }

          if (destroy) {
            destroy();
          }
        }
      };
    }

    function confettiCannon(canvas, globalOpts) {
      var isLibCanvas = !canvas;
      var allowResize = !!prop(globalOpts || {}, 'resize');
      var globalDisableForReducedMotion = prop(globalOpts, 'disableForReducedMotion', Boolean);
      var shouldUseWorker = canUseWorker && !!prop(globalOpts || {}, 'useWorker');
      var worker = shouldUseWorker ? getWorker() : null;
      var resizer = isLibCanvas ? setCanvasWindowSize : setCanvasRectSize;
      var initialized = canvas && worker ? !!canvas.__confetti_initialized : false;
      var preferLessMotion = typeof matchMedia === 'function' && matchMedia('(prefers-reduced-motion)').matches;
      var animationObj;

      function fireLocal(options, size, done) {
        var particleCount = prop(options, 'particleCount', Math.floor);
        var angle = prop(options, 'angle', Number);
        var spread = prop(options, 'spread', Number);
        var startVelocity = prop(options, 'startVelocity', Number);
        var decay = prop(options, 'decay', Number);
        var gravity = prop(options, 'gravity', Number);
        var colors = prop(options, 'colors');
        var ticks = prop(options, 'ticks', Number);
        var shapes = prop(options, 'shapes');
        var origin = getOrigin(options);
        var temp = particleCount;
        var fettis = [];
        var startX = canvas.width * origin.x;
        var startY = canvas.height * origin.y;

        while (temp--) {
          fettis.push(randomPhysics({
            x: startX,
            y: startY,
            angle: angle,
            spread: spread,
            startVelocity: startVelocity,
            color: colors[temp % colors.length],
            shape: shapes[randomInt(0, shapes.length)],
            ticks: ticks,
            decay: decay,
            gravity: gravity
          }));
        } // if we have a previous canvas already animating,
        // add to it


        if (animationObj) {
          return animationObj.addFettis(fettis);
        }

        animationObj = animate(canvas, fettis, resizer, size, done);
        return animationObj.promise;
      }

      function fire(options) {
        var disableForReducedMotion = globalDisableForReducedMotion || prop(options, 'disableForReducedMotion', Boolean);
        var zIndex = prop(options, 'zIndex', Number);

        if (disableForReducedMotion && preferLessMotion) {
          return promise(function (resolve) {
            resolve();
          });
        }

        if (isLibCanvas && animationObj) {
          // use existing canvas from in-progress animation
          canvas = animationObj.canvas;
        } else if (isLibCanvas && !canvas) {
          // create and initialize a new canvas
          canvas = getCanvas(zIndex);
          document.body.appendChild(canvas);
        }

        if (allowResize && !initialized) {
          // initialize the size of a user-supplied canvas
          resizer(canvas);
        }

        var size = {
          width: canvas.width,
          height: canvas.height
        };

        if (worker && !initialized) {
          worker.init(canvas);
        }

        initialized = true;

        if (worker) {
          canvas.__confetti_initialized = true;
        }

        function onResize() {
          if (worker) {
            // TODO this really shouldn't be immediate, because it is expensive
            var obj = {
              getBoundingClientRect: function getBoundingClientRect() {
                if (!isLibCanvas) {
                  return canvas.getBoundingClientRect();
                }
              }
            };
            resizer(obj);
            worker.postMessage({
              resize: {
                width: obj.width,
                height: obj.height
              }
            });
            return;
          } // don't actually query the size here, since this
          // can execute frequently and rapidly


          size.width = size.height = null;
        }

        function done() {
          animationObj = null;

          if (allowResize) {
            global.removeEventListener('resize', onResize);
          }

          if (isLibCanvas && canvas) {
            document.body.removeChild(canvas);
            canvas = null;
            initialized = false;
          }
        }

        if (allowResize) {
          global.addEventListener('resize', onResize, false);
        }

        if (worker) {
          return worker.fire(options, size, done);
        }

        return fireLocal(options, size, done);
      }

      fire.reset = function () {
        if (worker) {
          worker.reset();
        }

        if (animationObj) {
          animationObj.reset();
        }
      };

      return fire;
    }

    module.exports = confettiCannon(null, {
      useWorker: true,
      resize: true
    });
    module.exports.create = confettiCannon;
  })(function () {
    if (typeof window !== 'undefined') {
      return window;
    }

    if (typeof self !== 'undefined') {
      return self;
    }

    return this;
  }(), module$1, false); // end source content


  var confetti = module$1.exports;
  var create = module$1.exports.create;

  var Confetti = function Confetti() {
    babelHelpers.classCallCheck(this, Confetti);
  };
  babelHelpers.defineProperty(Confetti, "fire", confetti);
  babelHelpers.defineProperty(Confetti, "create", confetti.create);

  exports.Confetti = Confetti;

}((this.BX.UI = this.BX.UI || {})));
//# sourceMappingURL=confetti.bundle.js.map
